home *** CD-ROM | disk | FTP | other *** search
/ PC World 2007 March / PCWorld_2007-03_cd.bin / v cisle / httrack / httrack-3.41-2.exe / {app} / src / proxy / store.c < prev    next >
Encoding:
C/C++ Source or Header  |  2006-10-15  |  67.1 KB  |  2,248 lines
  1. /* ------------------------------------------------------------ */
  2. /*
  3. HTTrack Website Copier, Offline Browser for Windows and Unix
  4. Copyright (C) Xavier Roche and other contributors
  5.  
  6. This program is free software; you can redistribute it and/or
  7. modify it under the terms of the GNU General Public License
  8. as published by the Free Software Foundation; either version 2
  9. of the License, or any later version.
  10.  
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19.  
  20. Please visit our Website: http://www.httrack.com
  21. */
  22.  
  23. /* Parts (inside ARC format routines) by Lars Clausen (lc@statsbiblioteket.dk) */
  24.  
  25. /* ------------------------------------------------------------ */
  26. /* File: Cache manager for ProxyTrack                           */
  27. /* Author: Xavier Roche                                         */
  28. /* ------------------------------------------------------------ */
  29.  
  30. #include <stdio.h>
  31. #include <stdlib.h>
  32. #include <string.h>
  33. #include <time.h>
  34.  
  35. /* Locking */
  36. #ifdef _WIN32
  37. #include <process.h>    /* _beginthread, _endthread */
  38. #else
  39. #include <pthread.h>
  40. #endif
  41.  
  42. #include "htsglobal.h"
  43.  
  44. #define HTS_INTERNAL_BYTECODE
  45. #include "htsinthash.h"
  46. #include "htsmd5.h"
  47. #undef HTS_INTERNAL_BYTECODE
  48. #include "../minizip/mztools.h"
  49. #include "../minizip/zip.h"
  50.  
  51. #include "htscore.h"
  52. #include "htsback.h"
  53.  
  54. #include "store.h"
  55. #include "proxystrings.h"
  56. #include "proxytrack.h"
  57.  
  58. /* Unlocked functions */
  59.  
  60. static int PT_LookupCache__New_u(PT_Index index, const char* url);
  61. static PT_Element PT_ReadCache__New_u(PT_Index index, const char* url, int flags);
  62.  
  63. static int PT_LookupCache__Old_u(PT_Index index, const char* url);
  64. static PT_Element PT_ReadCache__Old_u(PT_Index index, const char* url, int flags);
  65.  
  66. static int PT_LookupCache__Arc_u(PT_Index index, const char* url);
  67. static PT_Element PT_ReadCache__Arc_u(PT_Index index, const char* url, int flags);
  68.  
  69. /* Locking */
  70.  
  71. #ifdef _WIN32
  72. void MutexInit(PT_Mutex *pMutex) {
  73.     *pMutex = CreateMutex(NULL,FALSE,NULL);
  74. }
  75.  
  76. void MutexLock(PT_Mutex *pMutex) {
  77.     WaitForSingleObject(*pMutex, INFINITE);
  78. }
  79.  
  80. void MutexUnlock(PT_Mutex *pMutex) {
  81.     ReleaseMutex(*pMutex);
  82. }
  83.  
  84. void MutexFree(PT_Mutex *pMutex) {
  85.     CloseHandle(*pMutex);
  86.     *pMutex = NULL;
  87. }
  88. #else
  89. void MutexInit(PT_Mutex *pMutex) {
  90.     (void) pthread_mutex_init(pMutex, 0);
  91. }
  92.  
  93. void MutexLock(PT_Mutex *pMutex) {
  94.     pthread_mutex_lock(pMutex);
  95. }
  96.  
  97. void MutexUnlock(PT_Mutex *pMutex) {
  98.     pthread_mutex_unlock(pMutex);
  99. }
  100.  
  101. void MutexFree(PT_Mutex *pMutex) {
  102.     pthread_mutex_destroy(pMutex);
  103. }
  104. #endif
  105.  
  106. /* Indexes */
  107.  
  108. typedef struct _PT_Index__New _PT_Index__New;
  109. typedef struct _PT_Index__Old _PT_Index__Old;
  110. typedef struct _PT_Index__Arc _PT_Index__Arc;
  111. typedef struct _PT_Index_Functions _PT_Index_Functions;
  112.  
  113. typedef struct _PT_Index__New *PT_Index__New;
  114. typedef struct _PT_Index__Old *PT_Index__Old;
  115. typedef struct _PT_Index__Arc *PT_Index__Arc;
  116. typedef struct _PT_Index_Functions *PT_Index_Functions;
  117.  
  118. enum {
  119.     PT_CACHE_UNDEFINED = -1,
  120.     PT_CACHE_MIN = 0,
  121.     PT_CACHE__NEW = PT_CACHE_MIN,
  122.     PT_CACHE__OLD,
  123.     PT_CACHE__ARC,
  124.     PT_CACHE_MAX = PT_CACHE__ARC
  125. };
  126.  
  127. static int PT_LoadCache__New(PT_Index index, const char *filename);
  128. static void PT_Index_Delete__New(PT_Index *pindex);
  129. static PT_Element PT_ReadCache__New(PT_Index index, const char* url, int flags);
  130. static int PT_LookupCache__New(PT_Index index, const char* url);
  131. static int PT_SaveCache__New(PT_Indexes indexes, const char *filename);
  132. /**/
  133. static int PT_LoadCache__Old(PT_Index index, const char *filename);
  134. static void PT_Index_Delete__Old(PT_Index *pindex);
  135. static PT_Element PT_ReadCache__Old(PT_Index index, const char* url, int flags);
  136. static int PT_LookupCache__Old(PT_Index index, const char* url);
  137. /**/
  138. static int PT_LoadCache__Arc(PT_Index index, const char *filename);
  139. static void PT_Index_Delete__Arc(PT_Index *pindex);
  140. static PT_Element PT_ReadCache__Arc(PT_Index index, const char* url, int flags);
  141. static int PT_LookupCache__Arc(PT_Index index, const char* url);
  142. static int PT_SaveCache__Arc(PT_Indexes indexes, const char *filename);
  143.  
  144. struct _PT_Index_Functions {
  145.     /* Mandatory services */
  146.     int (*PT_LoadCache)(PT_Index index, const char *filename);
  147.     void (*PT_Index_Delete)(PT_Index *pindex);
  148.     PT_Element (*PT_ReadCache)(PT_Index index, const char* url, int flags);
  149.     int (*PT_LookupCache)(PT_Index index, const char* url);
  150.  
  151.     /* Optional services */
  152.     int (*PT_SaveCache)(PT_Indexes indexes, const char *filename);
  153. };
  154.  
  155. static _PT_Index_Functions _IndexFuncts[] = {
  156.   { PT_LoadCache__New, PT_Index_Delete__New, PT_ReadCache__New, PT_LookupCache__New, PT_SaveCache__New },
  157.   { PT_LoadCache__Old, PT_Index_Delete__Old, PT_ReadCache__Old, PT_LookupCache__Old, NULL },
  158.   { PT_LoadCache__Arc, PT_Index_Delete__Arc, PT_ReadCache__Arc, PT_LookupCache__Arc, PT_SaveCache__Arc },
  159.     { NULL, NULL, NULL, NULL }
  160. };
  161.  
  162. #define PT_INDEX_COMMON_STRUCTURE \
  163.     time_t timestamp;                                \
  164.     inthash hash;                                        \
  165.     char startUrl[1024]
  166.  
  167. struct _PT_Index__New {
  168.     PT_INDEX_COMMON_STRUCTURE;
  169.     char path[1024];        /* either empty, or must include ending / */
  170.     int fixedPath;
  171.     int safeCache;
  172.     unzFile zFile;
  173.     PT_Mutex zFileLock;
  174. };
  175.  
  176. struct _PT_Index__Old {
  177.     PT_INDEX_COMMON_STRUCTURE;
  178.     char filenameDat[1024];
  179.     char filenameNdx[1024];
  180.     FILE *dat,*ndx;
  181.     PT_Mutex fileLock;
  182.     int version;
  183.     char lastmodified[1024];
  184.     char path[1024];        /* either empty, or must include ending / */
  185.     int fixedPath;
  186.     int safeCache;
  187. };
  188.  
  189. struct _PT_Index__Arc {
  190.     PT_INDEX_COMMON_STRUCTURE;
  191.     FILE *file;
  192.     PT_Mutex fileLock;
  193.     int version;
  194.     char lastmodified[1024];
  195.     char line[2048];
  196.     char filenameIndexBuff[2048];
  197. };
  198.  
  199. struct _PT_Index {
  200.     int type;
  201.     union {
  202.         _PT_Index__New formatNew;
  203.         _PT_Index__Old formatOld;
  204.         _PT_Index__Arc formatArc;
  205.         struct {
  206.             PT_INDEX_COMMON_STRUCTURE;
  207.         } common;
  208.     } slots;
  209. };
  210.  
  211. struct _PT_Indexes {
  212.     inthash cil;
  213.     struct _PT_Index **index;
  214.     int index_size;
  215. };
  216.  
  217. struct _PT_CacheItem {
  218.     time_t lastUsed;
  219.     size_t size;
  220.     void* data;
  221. };
  222.  
  223. struct _PT_Cache {
  224.     inthash index;
  225.     size_t maxSize;
  226.     size_t totalSize;
  227.     int count;
  228. };
  229.  
  230. PT_Indexes PT_New(void) {
  231.     PT_Indexes index = (PT_Indexes) calloc(sizeof(_PT_Indexes), 1);
  232.     index->cil = inthash_new(127);
  233.     index->index_size = 0;
  234.     index->index = NULL;
  235.     return index;
  236. }
  237.  
  238. void PT_Delete(PT_Indexes index) {
  239.     if (index != NULL) {
  240.         inthash_delete(&index->cil);
  241.         free(index);
  242.     }
  243. }
  244.  
  245. int PT_RemoveIndex(PT_Indexes index, int indexId) {
  246.     return 0;
  247. }
  248.  
  249. #define assertf(exp)
  250.  
  251. static int binput(char* buff,char* s,int max) {
  252.   int count = 0;
  253.   int destCount = 0;
  254.  
  255.   // Note: \0 will return 1
  256.   while(destCount < max && buff[count] != '\0' && buff[count] != '\n') {
  257.     if (buff[count] != '\r') {
  258.       s[destCount++] = buff[count];
  259.     }
  260.         count++;
  261.   }
  262.   s[destCount] = '\0';
  263.  
  264.   // then return the supplemental jump offset
  265.   return count + 1;
  266. }
  267.  
  268. static time_t file_timestamp(const char* file) {
  269.   struct stat buf;
  270.   if (stat(file, &buf) == 0) {
  271.     time_t tt = buf.st_mtime;
  272.         if (tt != (time_t) 0 && tt != (time_t) -1) {
  273.             return tt;
  274.         }
  275.   }
  276.   return (time_t) 0;
  277. }
  278.  
  279. static int PT_Index_Check__(PT_Index index, const char* file, int line) {
  280.     if (index == NULL)
  281.         return 0;
  282.     if (index->type >= PT_CACHE_MIN && index->type <= PT_CACHE_MAX)
  283.         return 1;
  284.     CRITICAL_("index corrupted in memory", file, line);
  285.     return 0;
  286. }
  287. #define SAFE_INDEX(index) PT_Index_Check__(index, __FILE__, __LINE__)
  288.  
  289.  
  290. /* ------------------------------------------------------------ */
  291. /* Generic cache dispatch                                       */
  292. /* ------------------------------------------------------------ */
  293.  
  294. void PT_Index_Delete(PT_Index *pindex) {
  295.     if (pindex != NULL && (*pindex) != NULL) {
  296.         PT_Index index = *pindex;
  297.         if (SAFE_INDEX(index)) {
  298.             _IndexFuncts[index->type].PT_Index_Delete(pindex);
  299.         }
  300.         free(index);
  301.         *pindex = NULL;
  302.     }
  303. }
  304.  
  305. static void PT_Index_Delete__New(PT_Index *pindex) {
  306.     if (pindex != NULL && (*pindex) != NULL) {
  307.         PT_Index__New index = &(*pindex)->slots.formatNew;
  308.         if (index->zFile != NULL) {
  309.             unzClose(index->zFile);
  310.             index->zFile = NULL;
  311.         }
  312.         if (index->hash != NULL) {
  313.             inthash_delete(&index->hash);
  314.             index->hash = NULL;
  315.         }
  316.         MutexFree(&index->zFileLock);
  317.     }
  318. }
  319.  
  320. static void PT_Index_Delete__Old(PT_Index *pindex) {
  321.     if (pindex != NULL && (*pindex) != NULL) {
  322.         PT_Index__Old index = &(*pindex)->slots.formatOld;
  323.         if (index->dat != NULL) {
  324.             fclose(index->dat);
  325.         }
  326.         if (index->ndx != NULL) {
  327.             fclose(index->ndx);
  328.         }
  329.         if (index->hash != NULL) {
  330.             inthash_delete(&index->hash);
  331.             index->hash = NULL;
  332.         }
  333.         MutexFree(&index->fileLock);
  334.     }
  335. }
  336.  
  337. static void PT_Index_Delete__Arc(PT_Index *pindex) {
  338.     if (pindex != NULL && (*pindex) != NULL) {
  339.         PT_Index__Arc index = &(*pindex)->slots.formatArc;
  340.         if (index->file != NULL) {
  341.             fclose(index->file);
  342.         }
  343.         MutexFree(&index->fileLock);
  344.     }
  345. }
  346.  
  347. int PT_AddIndex(PT_Indexes indexes, const char *path) {
  348.     PT_Index index = PT_LoadCache(path);
  349.     if (index != NULL) {
  350.         int ret = PT_IndexMerge(indexes, &index);
  351.         if (index != NULL) {
  352.             PT_Index_Delete(&index);
  353.         }
  354.         return ret;
  355.     }
  356.     return -1;
  357. }
  358.  
  359. PT_Element PT_Index_HTML_BuildRootInfo(PT_Indexes indexes) {
  360.     if (indexes != NULL) {
  361.         PT_Element elt = PT_ElementNew();
  362.         int i;
  363.         String html = STRING_EMPTY;
  364.         StringClear(html);
  365.         StringCat(html, 
  366.             "<html>"
  367.             PROXYTRACK_COMMENT_HEADER
  368.             DISABLE_IE_FRIENDLY_HTTP_ERROR_MESSAGES
  369.             "<head>\r\n"
  370.             "<title>ProxyTrack " PROXYTRACK_VERSION " Catalog</title>"
  371.             "</head>\r\n"
  372.             "<body>\r\n"
  373.             "<h3>Available sites in this cache:</h3><br />"
  374.             "<br />"
  375.             );
  376.         StringCat(html, "<ul>\r\n");
  377.         for(i = 0 ; i < indexes->index_size ; i++) {
  378.             if (indexes->index[i] != NULL
  379.                 && indexes->index[i]->slots.common.startUrl[0] != '\0')
  380.             {
  381.                 const char * url = indexes->index[i]->slots.common.startUrl;
  382.                 StringCat(html, "<li>\r\n");
  383.                 StringCat(html, "<a href=\"");
  384.                 StringCat(html, url);
  385.                 StringCat(html, "\">");
  386.                 StringCat(html, url);
  387.                 StringCat(html, "</a>\r\n");
  388.                 StringCat(html, "</li>\r\n");
  389.             }
  390.         }
  391.         StringCat(html, "</ul>\r\n");
  392.         StringCat(html, "</body></html>\r\n");
  393.         elt->size = StringLength(html);
  394.         elt->adr = StringAcquire(&html);
  395.         elt->statuscode = HTTP_OK;
  396.         strcpy(elt->charset, "iso-8859-1");
  397.         strcpy(elt->contenttype, "text/html");
  398.         strcpy(elt->msg, "OK");
  399.         StringFree(html);
  400.         return elt;
  401.     }
  402.     return NULL;
  403. }
  404.  
  405. static char* strchr_stop(char* str, char c, char stop) {
  406.     for( ; *str != 0 && *str != stop && *str != c ; str++);
  407.     if (*str == c)
  408.         return str;
  409.     return NULL;
  410. }
  411.  
  412. char ** PT_Enumerate(PT_Indexes indexes, const char *url, int subtree) {
  413.     // should be cached!
  414.     if (indexes != NULL && indexes->cil != NULL) {
  415.         unsigned int urlSize;
  416.         String list = STRING_EMPTY;
  417.         String listindexes = STRING_EMPTY;
  418.         String subitem = STRING_EMPTY;
  419.         unsigned int listCount = 0;
  420.         struct_inthash_enum en = inthash_enum_new(indexes->cil);
  421.         inthash_chain* chain;
  422.         inthash hdupes = NULL;
  423.         if (!subtree)
  424.             hdupes= inthash_new(127);
  425.         StringClear(list);
  426.         StringClear(listindexes);
  427.         StringClear(subitem);
  428.         if (strncmp(url, "http://", 7) == 0)
  429.             url += 7;
  430.         urlSize = (unsigned int) strlen(url);
  431.         while((chain = inthash_enum_next(&en))) {
  432.             long int index = (long int)chain->value.intg;
  433.             if (urlSize == 0 || strncmp(chain->name, url, urlSize) == 0) {
  434.                 if (index >= 0 && index < indexes->index_size) {
  435.                     char * item = chain->name + urlSize;
  436.                     if (*item == '/')
  437.                         item++;
  438.                     {
  439.                         char * pos = subtree ? 0 : strchr_stop(item, '/', '?');
  440.                         unsigned int len = pos ? (unsigned int)( pos - item ) : (unsigned int)strlen(item);
  441.                         if (len > 0 /* default document */ || *item == 0) {
  442.                             int isFolder = ( item[len] == '/' );
  443.                             StringClear(subitem);
  444.                             if (len > 0)
  445.                                 StringMemcat(subitem, item, len);
  446.                             if (len == 0 || !inthash_exists(hdupes, StringBuff(subitem))) {
  447.                                 char* ptr = NULL;
  448.                                 ptr += StringLength(list);
  449.                                 if (len > 0)
  450.                                     StringCat(list, StringBuff(subitem));
  451.                                 if (isFolder)
  452.                                     StringCat(list, "/");
  453.                                 StringMemcat(list, "\0", 1);        /* NULL terminated strings */
  454.                                 StringMemcat(listindexes, &ptr, sizeof(ptr));
  455.                                 listCount++;
  456.                                 inthash_write(hdupes, StringBuff(subitem), 0);
  457.                             }
  458.                         }
  459.                     }
  460.                 } else {
  461.                     CRITICAL("PT_Enumerate:Corrupted central index locator");
  462.                 }
  463.             }
  464.         }
  465.         StringFree(subitem);
  466.         inthash_delete(&hdupes);
  467.         if (listCount > 0) {
  468.             unsigned int i;
  469.             void* blk;
  470.             char *nullPointer = NULL;
  471.             char* startStrings;
  472.             /* NULL terminated index */
  473.             StringMemcat(listindexes, &nullPointer, sizeof(nullPointer));
  474.             /* start of all strings (index) */
  475.             startStrings = nullPointer + StringLength(listindexes);
  476.             /* copy list of URLs after indexes */
  477.             StringMemcat(listindexes, StringBuff(list), StringLength(list));
  478.             /* ---- no reallocation beyond this point (fixed addresses) ---- */
  479.             /* start of all strings (pointer) */
  480.             startStrings = (startStrings - nullPointer) + StringBuffRW(listindexes);
  481.             /* transform indexes into references */
  482.             for(i = 0 ; i < listCount ; i++) {
  483.                 char *ptr = NULL;
  484.                 unsigned int ndx;
  485.                 memcpy(&ptr, &StringBuff(listindexes)[i*sizeof(char*)], sizeof(char*));
  486.                 ndx = (unsigned int) (ptr - nullPointer);
  487.                 ptr = startStrings + ndx;
  488.                 memcpy(&StringBuffRW(listindexes)[i*sizeof(char*)], &ptr, sizeof(char*));
  489.             }
  490.             blk = StringAcquire(&listindexes);
  491.             StringFree(list);
  492.             StringFree(listindexes);
  493.             return (char **)blk;
  494.         }
  495.     }
  496.     return NULL;
  497. }
  498.  
  499. void PT_Enumerate_Delete(char ***plist) {
  500.     if (plist != NULL && *plist != NULL) {
  501.         free(*plist);
  502.         *plist = NULL;
  503.     }
  504. }
  505.  
  506. static int PT_GetType(const char *filename) {
  507.     char * dot = strrchr(filename, '.');
  508.     if (dot != NULL) {
  509.         if (strcasecmp(dot, ".zip") == 0) {
  510.             return PT_CACHE__NEW;
  511.         } else if (strcasecmp(dot, ".ndx") == 0 || strcasecmp(dot, ".dat") == 0) {
  512.             return PT_CACHE__OLD;
  513.         } else if (strcasecmp(dot, ".arc") == 0) {
  514.             return PT_CACHE__ARC;
  515.         }
  516.     }
  517.     return PT_CACHE_UNDEFINED;
  518. }
  519.  
  520. PT_Index PT_LoadCache(const char *filename) {
  521.     int type = PT_GetType(filename);
  522.     if (type != PT_CACHE_UNDEFINED) {
  523.         PT_Index index = calloc(sizeof(_PT_Index), 1);
  524.         if (index != NULL) {
  525.             index->type = type;
  526.             index->slots.common.timestamp = (time_t) time(NULL);
  527.             index->slots.common.startUrl[0] = '\0';
  528.             index->slots.common.hash = inthash_new(8191);
  529.             if (!_IndexFuncts[type].PT_LoadCache(index, filename)) {
  530.                 DEBUG("reading httrack cache (format #%d) %s : error" _ type _ filename );
  531.                 free(index);
  532.                 index = NULL;
  533.                 return NULL;
  534.             } else {
  535.                 DEBUG("reading httrack cache (format #%d) %s : success" _ type _ filename );
  536.             }
  537.             /* default starting URL is the first hash entry */
  538.             if (index->slots.common.startUrl[0] == '\0') {
  539.                 struct_inthash_enum en = inthash_enum_new(index->slots.common.hash);
  540.                 inthash_chain* chain;
  541.                 chain = inthash_enum_next(&en);
  542.                 if (chain != NULL
  543.                     && strstr(chain->name, "/robots.txt") != NULL) 
  544.                 {
  545.                     chain = inthash_enum_next(&en);
  546.                 }
  547.                 if (chain != NULL) {
  548.                     if (!link_has_authority(chain->name))
  549.                         strcat(index->slots.common.startUrl, "http://");
  550.                     strcat(index->slots.common.startUrl, chain->name);
  551.                 }
  552.             }
  553.         }
  554.         return index;
  555.     }
  556.     return NULL;
  557. }
  558.  
  559.  
  560. static long int filesize(const char* filename) {
  561.   struct stat st;
  562.   memset(&st, 0, sizeof(st));
  563.   if (stat(filename, &st) == 0) {
  564.         return (long int)st.st_size;
  565.   }
  566.   return -1;
  567. } 
  568.  
  569. int PT_LookupCache(PT_Index index, const char* url) {
  570.     if (index != NULL && SAFE_INDEX(index)) {
  571.         return _IndexFuncts[index->type].PT_LookupCache(index, url);
  572.     }
  573.     return 0;
  574. }
  575.  
  576. int PT_SaveCache(PT_Indexes indexes, const char *filename) {
  577.     int type = PT_GetType(filename);
  578.     if (type != PT_CACHE_UNDEFINED) {
  579.         if (_IndexFuncts[type].PT_SaveCache != NULL) {
  580.             int ret = _IndexFuncts[type].PT_SaveCache(indexes, filename);
  581.             if (ret == 0) {
  582.                 (void) set_filetime_time_t(filename, PT_GetTimeIndex(indexes));
  583.                 return 0;
  584.             }
  585.         }
  586.     }
  587.     return -1;
  588. }
  589.  
  590. int PT_EnumCache(PT_Indexes indexes, int (*callback)(void *, const char *url, PT_Element), void *arg) {
  591.     if (indexes != NULL && indexes->cil != NULL) {
  592.         struct_inthash_enum en = inthash_enum_new(indexes->cil);
  593.         inthash_chain* chain;
  594.         while((chain = inthash_enum_next(&en))) {
  595.             const long int index_id = (long int)chain->value.intg;
  596.             const char *const url = chain->name;
  597.             if (index_id >= 0 && index_id <= indexes->index_size) {
  598.                 PT_Element item =  PT_ReadCache(indexes->index[index_id], url, FETCH_HEADERS | FETCH_BODY);
  599.                 if (item != NULL) {
  600.                     int ret = callback(arg, url, item);
  601.                     PT_Element_Delete(&item);
  602.                     if (ret != 0)
  603.                         return ret;
  604.                 }
  605.             } else {
  606.                 CRITICAL("PT_ReadCache:Corrupted central index locator");
  607.                 return -1;
  608.             }
  609.         }
  610.     }
  611.     return 0;
  612. }
  613.  
  614. time_t PT_Index_Timestamp(PT_Index index) {
  615.     return index->slots.common.timestamp;
  616. }
  617.  
  618. static int PT_LookupCache__New(PT_Index index, const char* url) {
  619.     int retCode;
  620.     MutexLock(&index->slots.formatNew.zFileLock);
  621.     {
  622.         retCode = PT_LookupCache__New_u(index, url);
  623.     }
  624.     MutexUnlock(&index->slots.formatNew.zFileLock);
  625.     return retCode;
  626. }
  627.  
  628. static int PT_LookupCache__New_u(PT_Index index_, const char* url) {
  629.     if (index_ != NULL) {
  630.         PT_Index__New index = &index_->slots.formatNew;
  631.         if (index->hash != NULL && index->zFile != NULL && url != NULL && *url != 0) {
  632.             int hash_pos_return;
  633.             if (strncmp(url, "http://", 7) == 0)
  634.                 url += 7;
  635.             hash_pos_return = inthash_read(index->hash, url, NULL);
  636.             if (hash_pos_return)
  637.                 return 1;
  638.         }
  639.     }
  640.     return 0;
  641. }
  642.  
  643. int PT_IndexMerge(PT_Indexes indexes, PT_Index *pindex)
  644. {
  645.     if (pindex != NULL && *pindex != NULL && (*pindex)->slots.common.hash != NULL
  646.         && indexes != NULL) 
  647.     {
  648.         PT_Index index = *pindex;
  649.         struct_inthash_enum en = inthash_enum_new(index->slots.common.hash);
  650.         inthash_chain* chain;
  651.         int index_id = indexes->index_size++;
  652.         int nMerged = 0;
  653.         if ((indexes->index = realloc(indexes->index, sizeof(struct _PT_Index)*indexes->index_size)) != NULL) {
  654.             indexes->index[index_id] = index;
  655.             *pindex = NULL;
  656.             while((chain = inthash_enum_next(&en)) != NULL) {
  657.                 const char * url = chain->name;
  658.                 if (url != NULL && url[0] != '\0') {
  659.                     intptr_t previous_index_id = 0;
  660.                     if (inthash_read(indexes->cil, url, &previous_index_id)) {
  661.                         if (previous_index_id >= 0 && previous_index_id < indexes->index_size) {
  662.                             if (indexes->index[previous_index_id]->slots.common.timestamp > index->slots.common.timestamp)            // existing entry is newer
  663.                                 break;
  664.                         } else {
  665.                             CRITICAL("PT_IndexMerge:Corrupted central index locator");
  666.                         }
  667.                     }
  668.                     inthash_write(indexes->cil, chain->name, index_id);
  669.                     nMerged++;
  670.                 }
  671.             }
  672.         } else {
  673.             CRITICAL("PT_IndexMerge:Memory exhausted");
  674.         }
  675.         return nMerged;
  676.     }
  677.     return -1;
  678. }
  679.  
  680. void PT_Element_Delete(PT_Element *pentry) {
  681.     if (pentry != NULL) {
  682.         PT_Element entry = *pentry;
  683.         if (entry != NULL) {
  684.             if (entry->adr != NULL) {
  685.                 free(entry->adr);
  686.                 entry->adr = NULL;
  687.             }
  688.             if (entry->headers != NULL) {
  689.                 free(entry->headers);
  690.                 entry->headers = NULL;
  691.             }
  692.             if (entry->location != NULL) {
  693.                 free(entry->location);
  694.                 entry->location = NULL;
  695.             }
  696.             free(entry);
  697.         }
  698.         *pentry = NULL;
  699.     }
  700. }
  701.  
  702. PT_Element PT_ReadIndex(PT_Indexes indexes, const char* url, int flags)
  703. {
  704.     if (indexes != NULL) 
  705.     {
  706.         intptr_t index_id;
  707.         if (strncmp(url, "http://", 7) == 0)
  708.             url += 7;
  709.         if (inthash_read(indexes->cil, url, &index_id)) {
  710.             if (index_id >= 0 && index_id <= indexes->index_size) {
  711.                 PT_Element item =  PT_ReadCache(indexes->index[index_id], url, flags);
  712.                 if (item != NULL) {
  713.                     item->indexId = (int) index_id;
  714.                     return item;
  715.                 }
  716.             } else {
  717.                 CRITICAL("PT_ReadCache:Corrupted central index locator");
  718.             }
  719.         }
  720.     }
  721.     return NULL;
  722. }
  723.  
  724. int PT_LookupIndex(PT_Indexes indexes, const char* url) {
  725.     if (indexes != NULL) 
  726.     {
  727.         intptr_t index_id;
  728.         if (strncmp(url, "http://", 7) == 0)
  729.             url += 7;
  730.         if (inthash_read(indexes->cil, url, &index_id)) {
  731.             if (index_id >= 0 && index_id <= indexes->index_size) {
  732.                 return 1;
  733.             } else {
  734.                 CRITICAL("PT_ReadCache:Corrupted central index locator");
  735.             }
  736.         }
  737.     }
  738.     return 0;
  739. }
  740.  
  741. time_t PT_GetTimeIndex(PT_Indexes indexes) {
  742.     if (indexes != NULL && indexes->index_size > 0) 
  743.     {
  744.         int i;
  745.         time_t maxt = indexes->index[0]->slots.common.timestamp;
  746.         for(i = 1 ; i < indexes->index_size ; i++) {
  747.             const time_t currt = indexes->index[i]->slots.common.timestamp;
  748.             if (currt > maxt) {
  749.                 maxt = currt;
  750.             }
  751.         }
  752.         return maxt;
  753.     }
  754.     return (time_t) -1;
  755. }
  756.  
  757. PT_Index PT_GetIndex(PT_Indexes indexes, int indexId) {
  758.     if (indexes != NULL && indexId >= 0 && indexId < indexes->index_size) 
  759.     {
  760.         return indexes->index[indexId];
  761.     }
  762.     return NULL;
  763. }
  764.  
  765. PT_Element PT_ElementNew(void) {
  766.     PT_Element r = NULL;
  767.     if ((r = calloc(sizeof(_PT_Element), 1)) == NULL)
  768.         return NULL;
  769.     r->statuscode=STATUSCODE_INVALID;
  770.     r->indexId = -1;
  771.     return r;
  772. }
  773.  
  774. PT_Element PT_ReadCache(PT_Index index, const char* url, int flags) {
  775.     if (index != NULL && SAFE_INDEX(index)) {
  776.         return _IndexFuncts[index->type].PT_ReadCache(index, url, flags);
  777.     }
  778.     return NULL;
  779. }
  780.  
  781. static PT_Element PT_ReadCache__New(PT_Index index, const char* url, int flags) {
  782.     PT_Element retCode;
  783.     MutexLock(&index->slots.formatNew.zFileLock);
  784.     {
  785.         retCode = PT_ReadCache__New_u(index, url, flags);
  786.     }
  787.     MutexUnlock(&index->slots.formatNew.zFileLock);
  788.     return retCode;
  789. }
  790.  
  791.  
  792. /* ------------------------------------------------------------ */
  793. /* New HTTrack cache (new.zip) format                           */
  794. /* ------------------------------------------------------------ */
  795.  
  796. #define ZIP_FIELD_STRING(headers, headersSize, field, value) do { \
  797.   if ( (value != NULL) && (value)[0] != '\0') { \
  798.     sprintf(headers + headersSize, "%s: %s\r\n", field, (value != NULL) ? (value) : ""); \
  799.     (headersSize) += (int) strlen(headers + headersSize); \
  800.   } \
  801. } while(0)
  802. #define ZIP_FIELD_INT(headers, headersSize, field, value) do { \
  803.   if ( (value != 0) ) { \
  804.     sprintf(headers + headersSize, "%s: "LLintP"\r\n", field, (LLint)(value)); \
  805.     (headersSize) += (int) strlen(headers + headersSize); \
  806.   } \
  807. } while(0)
  808. #define ZIP_FIELD_INT_FORCE(headers, headersSize, field, value) do { \
  809.   sprintf(headers + headersSize, "%s: "LLintP"\r\n", field, (LLint)(value)); \
  810.   (headersSize) += (int) strlen(headers + headersSize); \
  811. } while(0)
  812. #define ZIP_READFIELD_STRING(line, value, refline, refvalue) do { \
  813.   if (line[0] != '\0' && strfield2(line, refline)) { \
  814.     strcpy(refvalue, value); \
  815.     line[0] = '\0'; \
  816.     } \
  817. } while(0)
  818. #define ZIP_READFIELD_INT(line, value, refline, refvalue) do { \
  819.   if (line[0] != '\0' && strfield2(line, refline)) { \
  820.     int intval = 0; \
  821.     sscanf(value, "%d", &intval); \
  822.     (refvalue) = intval; \
  823.     line[0] = '\0'; \
  824.     } \
  825. } while(0)
  826.  
  827. int PT_LoadCache__New(PT_Index index_, const char *filename) {
  828.     if (index_ != NULL && filename != NULL) {
  829.         PT_Index__New index = &index_->slots.formatNew;
  830.         unzFile zFile = index->zFile = unzOpen(filename);
  831.         index->timestamp = file_timestamp(filename);
  832.         MutexInit(&index->zFileLock);
  833.  
  834.         // Opened ?
  835.         if (zFile!=NULL) {
  836.             const char * abpath;
  837.             int slashes;
  838.             inthash hashtable = index->hash;
  839.  
  840.             /* Compute base path for this index - the filename MUST be absolute! */
  841.             for(slashes = 2, abpath = filename + (int)strlen(filename) - 1 
  842.                 ; abpath > filename && ( ( *abpath != '/'&& *abpath != '\\' ) || --slashes > 0)
  843.                 ; abpath--);
  844.             index->path[0] = '\0';
  845.             if (slashes == 0 && *abpath != 0) {
  846.                 int i;
  847.                 strncat(index->path, filename, (int) ( abpath - filename ) + 1 );
  848.                 for(i = 0 ; index->path[i] != 0 ; i++) {
  849.                     if (index->path[i] == '\\') {
  850.                         index->path[i] = '/';
  851.                     }
  852.                 }
  853.             }
  854.  
  855.             /* Ready directory entries */
  856.             if (unzGoToFirstFile(zFile) == Z_OK) {
  857.                 char comment[128];
  858.                 char filename[HTS_URLMAXSIZE * 4];
  859.                 int entries = 0;
  860.                 int firstSeen = 0;
  861.                 memset(comment, 0, sizeof(comment));       // for truncated reads
  862.                 do  {
  863.                     int readSizeHeader = 0;
  864.                     filename[0] = '\0';
  865.                     comment[0] = '\0';
  866.                     if (unzOpenCurrentFile(zFile) == Z_OK) {
  867.                         if (
  868.                             (readSizeHeader = unzGetLocalExtrafield(zFile, comment, sizeof(comment) - 2)) > 0
  869.                             &&
  870.                             unzGetCurrentFileInfo(zFile, NULL, filename, sizeof(filename) - 2, NULL, 0, NULL, 0) == Z_OK
  871.                             ) 
  872.                         {
  873.                             long int pos = (long int) unzGetOffset(zFile);
  874.                             assertf(readSizeHeader < sizeof(comment));
  875.                             comment[readSizeHeader] = '\0';
  876.                             entries++;
  877.                             if (pos > 0) {
  878.                                 int dataincache = 0;    // data in cache ?
  879.                                 char* filenameIndex = filename;
  880.                                 if (strncmp(filenameIndex, "http://", 7) == 0) {
  881.                                     filenameIndex += 7;
  882.                                 }
  883.                                 if (comment[0] != '\0') {
  884.                                     int maxLine = 2;
  885.                                     char* a = comment;
  886.                                     while(*a && maxLine-- > 0) {      // parse only few first lines
  887.                                         char line[1024];
  888.                                         line[0] = '\0';
  889.                                         a+=binput(a, line, sizeof(line) - 2);
  890.                                         if (strncmp(line, "X-In-Cache:", 11) == 0) {
  891.                                             if (strcmp(line, "X-In-Cache: 1") == 0) {
  892.                                                 dataincache = 1;
  893.                                             } else {
  894.                                                 dataincache = 0;
  895.                                             }
  896.                                             break;
  897.                                         }
  898.                                     }
  899.                                 }
  900.                                 if (dataincache)
  901.                                     inthash_add(hashtable, filenameIndex, pos);
  902.                                 else
  903.                                     inthash_add(hashtable, filenameIndex, -pos);
  904.  
  905.                                 /* First link as starting URL */
  906.                                 if (!firstSeen) {
  907.                                     if (strstr(filenameIndex, "/robots.txt") == NULL) {
  908.                                         firstSeen = 1;
  909.                                         if (!link_has_authority(filenameIndex))
  910.                                             strcat(index->startUrl, "http://");
  911.                                         strcat(index->startUrl, filenameIndex);
  912.                                     }
  913.                                 }
  914.                             } else {
  915.                                 fprintf(stderr, "Corrupted cache meta entry #%d"LF, (int)entries);
  916.                             }
  917.                         } else {
  918.                             fprintf(stderr, "Corrupted cache entry #%d"LF, (int)entries);
  919.                         }
  920.                         unzCloseCurrentFile(zFile);
  921.                     } else {
  922.                         fprintf(stderr, "Corrupted cache entry #%d"LF, (int)entries);
  923.                     }
  924.                 } while( unzGoToNextFile(zFile) == Z_OK );
  925.                 return 1;
  926.             } else {
  927.                 inthash_delete(&index->hash);
  928.                 index = NULL;
  929.             }
  930.         } else {
  931.             index = NULL;
  932.         }
  933.     }
  934.     return 0;
  935. }
  936.  
  937. static PT_Element PT_ReadCache__New_u(PT_Index index_, const char* url, int flags)
  938. {
  939.     PT_Index__New index = (PT_Index__New) &index_->slots.formatNew;
  940.   char location_default[HTS_URLMAXSIZE*2];
  941.   char previous_save[HTS_URLMAXSIZE*2];
  942.   char previous_save_[HTS_URLMAXSIZE*2];
  943.     char catbuff[CATBUFF_SIZE];
  944.   intptr_t hash_pos;
  945.   int hash_pos_return;
  946.     PT_Element r = NULL;
  947.     if (index == NULL || index->hash == NULL || index->zFile == NULL || url == NULL || *url == 0)
  948.         return NULL;
  949.     if ((r = PT_ElementNew()) == NULL)
  950.         return NULL;
  951.     location_default[0] = '\0';
  952.     previous_save[0] = previous_save_[0] = '\0';
  953.   memset(r, 0, sizeof(_PT_Element));
  954.   r->location = location_default;
  955.     strcpy(r->location, ""); 
  956.     if (strncmp(url, "http://", 7) == 0)
  957.         url += 7;
  958.   hash_pos_return = inthash_read(index->hash, url, &hash_pos);
  959.  
  960.   if (hash_pos_return) {
  961.     uLong posInZip;
  962.     if (hash_pos > 0) {
  963.       posInZip = (uLong) hash_pos;
  964.     } else {
  965.       posInZip = (uLong) -hash_pos;
  966.     }
  967.         if (unzSetOffset(index->zFile, posInZip) == Z_OK) {
  968.       /* Read header (Max 8KiB) */
  969.       if (unzOpenCurrentFile(index->zFile) == Z_OK) {
  970.         char headerBuff[8192 + 2];
  971.         int readSizeHeader;
  972.         int totalHeader = 0;
  973.         int dataincache = 0;
  974.         
  975.         /* For BIG comments */
  976.         headerBuff[0] 
  977.           = headerBuff[sizeof(headerBuff) - 1] 
  978.           = headerBuff[sizeof(headerBuff) - 2] 
  979.           = headerBuff[sizeof(headerBuff) - 3] = '\0';
  980.  
  981.         if ( (readSizeHeader = unzGetLocalExtrafield(index->zFile, headerBuff, sizeof(headerBuff) - 2)) > 0) 
  982.         {
  983.           int offset = 0;
  984.           char line[HTS_URLMAXSIZE + 2];
  985.           int lineEof = 0;
  986.           headerBuff[readSizeHeader] = '\0';
  987.           do {
  988.             char* value;
  989.             line[0] = '\0';
  990.             offset += binput(headerBuff + offset, line, sizeof(line) - 2);
  991.             if (line[0] == '\0') {
  992.               lineEof = 1;
  993.             }
  994.             value = strchr(line, ':');
  995.             if (value != NULL) {
  996.               *value++ = '\0';
  997.               if (*value == ' ' || *value == '\t') value++;
  998.               ZIP_READFIELD_INT(line, value, "X-In-Cache", dataincache);
  999.               ZIP_READFIELD_INT(line, value, "X-Statuscode", r->statuscode);
  1000.               ZIP_READFIELD_STRING(line, value, "X-StatusMessage", r->msg);              // msg
  1001.               ZIP_READFIELD_INT(line, value, "X-Size", r->size);           // size
  1002.               ZIP_READFIELD_STRING(line, value, "Content-Type", r->contenttype);      // contenttype
  1003.               ZIP_READFIELD_STRING(line, value, "X-Charset", r->charset);          // contenttype
  1004.               ZIP_READFIELD_STRING(line, value, "Last-Modified", r->lastmodified);     // last-modified
  1005.               ZIP_READFIELD_STRING(line, value, "Etag", r->etag);             // Etag
  1006.               ZIP_READFIELD_STRING(line, value, "Location", r->location);         // 'location' pour moved
  1007.               ZIP_READFIELD_STRING(line, value, "Content-Disposition", r->cdispo);           // Content-disposition
  1008.               //ZIP_READFIELD_STRING(line, value, "X-Addr", ..);            // Original address
  1009.               //ZIP_READFIELD_STRING(line, value, "X-Fil", ..);            // Original URI filename
  1010.               ZIP_READFIELD_STRING(line, value, "X-Save", previous_save_);           // Original save filename
  1011.                             if (line[0] != '\0') {
  1012.                                 int len = r->headers ? ((int) strlen(r->headers)) : 0;
  1013.                                 int nlen = (int) ( strlen(line) + 2 + strlen(value) + sizeof("\r\n") + 1 );
  1014.                                 r->headers = realloc(r->headers, len + nlen);
  1015.                                 r->headers[len] = '\0';
  1016.                                 strcat(r->headers, line);
  1017.                                 strcat(r->headers, ": ");
  1018.                                 strcat(r->headers, value);
  1019.                                 strcat(r->headers, "\r\n");
  1020.                             }
  1021.             }
  1022.           } while(offset < readSizeHeader && !lineEof);
  1023.           totalHeader = offset;
  1024.  
  1025.                     /* Previous entry */
  1026.                     if (previous_save_[0] != '\0') {
  1027.                         int pathLen = (int) strlen(index->path);
  1028.                         if (pathLen > 0 && strncmp(previous_save_, index->path, pathLen) == 0) {            // old (<3.40) buggy format
  1029.                             strcpy(previous_save, previous_save_);
  1030.                         }
  1031.                         // relative ? (hack)
  1032.                         else if (index->safeCache
  1033.                             || (previous_save_[0] != '/'                                                                    // /home/foo/bar.gif
  1034.                             && ( !isalpha(previous_save_[0]) || previous_save_[1] != ':' ) )    // c:/home/foo/bar.gif
  1035.                             )
  1036.                         {
  1037.                             index->safeCache = 1;
  1038.                             sprintf(previous_save, "%s%s", index->path, previous_save_);
  1039.                         }
  1040.                         // bogus format (includes buggy absolute path)
  1041.                         else {
  1042.                             /* guess previous path */
  1043.                             if (index->fixedPath == 0) {
  1044.                                 const char * start = jump_protocol_and_auth(url);
  1045.                                 const char * end = start ? strchr(start, '/') : NULL;
  1046.                                 int len = (int) (end - start);
  1047.                                 if (start != NULL && end != NULL && len > 0 && len < 128) {
  1048.                                     char piece[128 + 2];
  1049.                                     const char * where;
  1050.                                     piece[0] = '\0';
  1051.                                     strncat(piece, start, len);
  1052.                                     if ((where = strstr(previous_save_, piece)) != NULL) {
  1053.                                         index->fixedPath = (int) (where - previous_save_);        // offset to relative path
  1054.                                     }
  1055.                                 }
  1056.                             }
  1057.                             if (index->fixedPath > 0) {
  1058.                                 int saveLen = (int) strlen(previous_save_);
  1059.                                 if (index->fixedPath < saveLen) {
  1060.                                     sprintf(previous_save, "%s%s", index->path, previous_save_ + index->fixedPath);
  1061.                                 } else {
  1062.                                     sprintf(r->msg, "Bogus fixePath prefix for %s (prefixLen=%d)", previous_save_, (int)index->fixedPath);
  1063.                                     r->statuscode = STATUSCODE_INVALID;
  1064.                                 }
  1065.                             } else {
  1066.                                 sprintf(previous_save, "%s%s", index->path, previous_save_);
  1067.                             }
  1068.                         }
  1069.                     }
  1070.  
  1071.           /* Complete fields */
  1072.           r->adr=NULL;
  1073.           if (r->statuscode != STATUSCODE_INVALID) {            /* Can continue */
  1074.             int ok = 0;
  1075.                        
  1076.             // Court-circuit:
  1077.             // Peut-on stocker le fichier directement sur disque?
  1078.             if (ok) {
  1079.               if (r->msg[0] == '\0') {
  1080.                 strcpy(r->msg,"Cache Read Error : Unexpected error");
  1081.               }
  1082.             } else { // lire en mΘmoire
  1083.               
  1084.               if (!dataincache) {
  1085.                                 /* Read in memory from cache */
  1086.                                 if (flags & FETCH_BODY) {
  1087.                                     if (strnotempty(previous_save)) {
  1088.                                         FILE* fp = fopen(fconv(catbuff,previous_save), "rb");
  1089.                                         if (fp != NULL) {
  1090.                                             r->adr = (char*) malloc(r->size + 4);
  1091.                                             if (r->adr != NULL) {
  1092.                                                 if (r->size > 0 && fread(r->adr, 1,  r->size, fp) != r->size) {
  1093.                           int last_errno = errno;
  1094.                                                     r->statuscode=STATUSCODE_INVALID;
  1095.                                                     sprintf(r->msg,"Read error in cache disk data: %s", strerror(last_errno));
  1096.                                                 }
  1097.                                             } else {
  1098.                                                 r->statuscode=STATUSCODE_INVALID;
  1099.                                                 strcpy(r->msg,"Read error (memory exhausted) from cache");
  1100.                                             }
  1101.                                             fclose(fp);
  1102.                                         } else {
  1103.                                             r->statuscode=STATUSCODE_INVALID;
  1104.                                             sprintf(r->msg, "Read error (can't open '%s') from cache", fconv(catbuff,previous_save));
  1105.                                         }
  1106.                                     } else {
  1107.                                         r->statuscode=STATUSCODE_INVALID;
  1108.                                         strcpy(r->msg,"Cached file name is invalid");
  1109.                                     }
  1110.                                 }
  1111.               } else {
  1112.                                 // lire fichier (d'un coup)
  1113.                                 if (flags & FETCH_BODY) {
  1114.                                     r->adr=(char*) malloc(r->size+1);
  1115.                                     if (r->adr!=NULL) {
  1116.                                         if (unzReadCurrentFile(index->zFile, r->adr, (unsigned int) r->size) != r->size) {  // erreur
  1117.                                             free(r->adr);
  1118.                                             r->adr=NULL;
  1119.                                             r->statuscode=STATUSCODE_INVALID;
  1120.                                             strcpy(r->msg,"Cache Read Error : Read Data");
  1121.                                         } else
  1122.                                             *(r->adr+r->size)='\0';
  1123.                                         //printf(">%s status %d\n",back[p].r->contenttype,back[p].r->statuscode);
  1124.                                     } else {  // erreur
  1125.                                         r->statuscode=STATUSCODE_INVALID;
  1126.                                         strcpy(r->msg,"Cache Memory Error");
  1127.                                     }
  1128.                                 }
  1129.                             }
  1130.             }
  1131.           }    // si save==null, ne rien charger (juste en tΩte)
  1132.         } else {
  1133.           r->statuscode=STATUSCODE_INVALID;
  1134.           strcpy(r->msg,"Cache Read Error : Read Header Data");
  1135.         }
  1136.         unzCloseCurrentFile(index->zFile);
  1137.       } else {
  1138.         r->statuscode=STATUSCODE_INVALID;
  1139.         strcpy(r->msg,"Cache Read Error : Open File");
  1140.       }
  1141.  
  1142.     } else {
  1143.       r->statuscode=STATUSCODE_INVALID;
  1144.       strcpy(r->msg,"Cache Read Error : Bad Offset");
  1145.     }
  1146.   } else {
  1147.     r->statuscode=STATUSCODE_INVALID;
  1148.     strcpy(r->msg,"File Cache Entry Not Found");
  1149.   }
  1150.     if (r->location[0] != '\0') {
  1151.         r->location = strdup(r->location);
  1152.     } else {
  1153.         r->location = NULL;
  1154.     }
  1155.   return r;
  1156. }
  1157.  
  1158. static int PT_SaveCache__New_Fun(void *arg, const char *url, PT_Element element) {
  1159.     zipFile zFileOut = (zipFile) arg;
  1160.     char headers[8192];
  1161.   int headersSize;
  1162.   zip_fileinfo fi;
  1163.     int zErr;
  1164.     const char *url_adr = "";
  1165.     const char *url_fil = "";
  1166.  
  1167.   headers[0] = '\0';
  1168.   headersSize = 0;
  1169.  
  1170.   /* Fields */
  1171.   headers[0] = '\0';
  1172.   headersSize = 0;
  1173.   /* */
  1174.   {
  1175.     char* message;
  1176.     if (strlen(element->msg) < 32) {
  1177.       message = element->msg;
  1178.     } else {
  1179.       message = "(See X-StatusMessage)";
  1180.     }
  1181.     /* 64 characters MAX for first line */
  1182.         sprintf(headers + headersSize, "HTTP/1.%c %d %s\r\n", '1', element->statuscode, element->msg);
  1183.   }
  1184.   headersSize += (int) strlen(headers + headersSize);
  1185.  
  1186.   /* Second line MUST ALWAYS be X-In-Cache */
  1187.   ZIP_FIELD_INT_FORCE(headers, headersSize, "X-In-Cache", 1);
  1188.   ZIP_FIELD_INT(headers, headersSize, "X-StatusCode", element->statuscode);
  1189.   ZIP_FIELD_STRING(headers, headersSize, "X-StatusMessage", element->msg);
  1190.   ZIP_FIELD_INT(headers, headersSize, "X-Size", element->size);           // size
  1191.   ZIP_FIELD_STRING(headers, headersSize, "Content-Type", element->contenttype);      // contenttype
  1192.   ZIP_FIELD_STRING(headers, headersSize, "X-Charset", element->charset);          // contenttype
  1193.   ZIP_FIELD_STRING(headers, headersSize, "Last-Modified", element->lastmodified);     // last-modified
  1194.   ZIP_FIELD_STRING(headers, headersSize, "Etag", element->etag);             // Etag
  1195.   ZIP_FIELD_STRING(headers, headersSize, "Location", element->location);         // 'location' pour moved
  1196.   ZIP_FIELD_STRING(headers, headersSize, "Content-Disposition", element->cdispo);           // Content-disposition
  1197.   ZIP_FIELD_STRING(headers, headersSize, "X-Addr", url_adr);            // Original address
  1198.   ZIP_FIELD_STRING(headers, headersSize, "X-Fil", url_fil);            // Original URI filename
  1199.   ZIP_FIELD_STRING(headers, headersSize, "X-Save", "");           // Original save filename
  1200.   
  1201.   /* Time */
  1202.   memset(&fi, 0, sizeof(fi));
  1203.   if (element->lastmodified[0] != '\0') {
  1204.         struct tm buffer;
  1205.     struct tm* tm_s = convert_time_rfc822(&buffer, element->lastmodified);
  1206.     if (tm_s) {
  1207.       fi.tmz_date.tm_sec = (uInt) tm_s->tm_sec;
  1208.       fi.tmz_date.tm_min = (uInt) tm_s->tm_min;
  1209.       fi.tmz_date.tm_hour = (uInt) tm_s->tm_hour;
  1210.       fi.tmz_date.tm_mday = (uInt) tm_s->tm_mday;
  1211.       fi.tmz_date.tm_mon = (uInt) tm_s->tm_mon;
  1212.       fi.tmz_date.tm_year = (uInt) tm_s->tm_year;
  1213.     }
  1214.   }
  1215.  
  1216.   /* Open file - NOTE: headers in "comment" */
  1217.   if ((zErr = zipOpenNewFileInZip(zFileOut,
  1218.     url,
  1219.     &fi,
  1220.     /* 
  1221.     Store headers in realtime in the local file directory as extra field
  1222.     In case of crash, we'll be able to recover the whole ZIP file by rescanning it
  1223.     */
  1224.     headers,
  1225.     (uInt) strlen(headers),
  1226.     NULL,
  1227.     0,
  1228.     NULL, /* comment */
  1229.     Z_DEFLATED,
  1230.     Z_DEFAULT_COMPRESSION)) != Z_OK)
  1231.   {
  1232.     int zip_zipOpenNewFileInZip_failed = 0;
  1233.     assertf(zip_zipOpenNewFileInZip_failed);
  1234.   }
  1235.   
  1236.     /* Write data in cache */
  1237.     if (element->size > 0 && element->adr != NULL) {
  1238.         if ((zErr = zipWriteInFileInZip(zFileOut, element->adr, (int) element->size)) != Z_OK) {
  1239.             int zip_zipWriteInFileInZip_failed = 0;
  1240.             assertf(zip_zipWriteInFileInZip_failed);
  1241.         }
  1242.     }
  1243.  
  1244.     /* Close */
  1245.     if ((zErr = zipCloseFileInZip(zFileOut)) != Z_OK) {
  1246.         int zip_zipCloseFileInZip_failed = 0;
  1247.     assertf(zip_zipCloseFileInZip_failed);
  1248.   }
  1249.  
  1250.   /* Flush */
  1251.   if ((zErr = zipFlush(zFileOut)) != 0) {
  1252.     int zip_zipFlush_failed = 0;
  1253.     assertf(zip_zipFlush_failed);
  1254.   }
  1255.  
  1256.     return 0;
  1257. }
  1258.  
  1259. static int PT_SaveCache__New(PT_Indexes indexes, const char *filename) {
  1260.     zipFile zFileOut = zipOpen(filename, 0);
  1261.     if (zFileOut != NULL) {
  1262.         int ret = PT_EnumCache(indexes, PT_SaveCache__New_Fun, (void *) zFileOut);
  1263.     zipClose(zFileOut, "Created by HTTrack Website Copier/ProxyTrack "PROXYTRACK_VERSION);
  1264.         zFileOut = NULL;
  1265.         if (ret != 0)
  1266.             (void) unlink(filename);
  1267.         return ret;
  1268.     }
  1269.     return -1;
  1270. }
  1271.  
  1272.  
  1273.  
  1274. /* ------------------------------------------------------------ */
  1275. /* Old HTTrack cache (dat/ndx) format                           */
  1276. /* ------------------------------------------------------------ */
  1277.  
  1278. static int cache_brstr(char* adr,char* s) {
  1279.   int i;
  1280.   int off;
  1281.   char buff[256 + 1];
  1282.   off=binput(adr,buff,256);
  1283.   adr+=off;
  1284.   sscanf(buff,"%d",&i);
  1285.   if (i>0)
  1286.     strncpy(s,adr,i);
  1287.   *(s+i)='\0';
  1288.   off+=i;
  1289.   return off;
  1290. }
  1291.  
  1292. static void cache_rstr(FILE* fp,char* s) {
  1293.   INTsys i;
  1294.   char buff[256+4];
  1295.   linput(fp,buff,256);
  1296.   sscanf(buff,INTsysP,&i);
  1297.   if (i < 0 || i > 32768)    /* error, something nasty happened */
  1298.     i=0;
  1299.   if (i>0) {
  1300.     if ((int) fread(s,1,i,fp) != i) {
  1301.       int fread_cache_failed = 0;
  1302.       assertf(fread_cache_failed);
  1303.     }
  1304.   }
  1305.   *(s+i)='\0';
  1306. }
  1307.  
  1308. static char* cache_rstr_addr(FILE* fp) {
  1309.   INTsys i;
  1310.   char* addr = NULL;
  1311.   char buff[256+4];
  1312.   linput(fp,buff,256);
  1313.   sscanf(buff,"%d",&i);
  1314.   if (i < 0 || i > 32768)    /* error, something nasty happened */
  1315.     i=0;
  1316.   if (i > 0) {
  1317.     addr = malloc(i + 1);
  1318.     if (addr != NULL) {
  1319.       if ((int) fread(addr,1,i,fp) != i) {
  1320.         int fread_cache_failed = 0;
  1321.         assertf(fread_cache_failed);
  1322.       }
  1323.       *(addr+i)='\0';
  1324.     }
  1325.   }
  1326.   return addr;
  1327. }
  1328.  
  1329. static void cache_rint(FILE* fp,int* i) {
  1330.   char s[256];
  1331.   cache_rstr(fp,s);
  1332.   sscanf(s,"%d",i);
  1333. }
  1334.  
  1335. static void cache_rLLint(FILE* fp,unsigned long* i) {
  1336.     int l;
  1337.   char s[256];
  1338.   cache_rstr(fp,s);
  1339.   sscanf(s,"%d",&l);
  1340.     *i = (unsigned long)l;
  1341. }
  1342.  
  1343. static int PT_LoadCache__Old(PT_Index index_, const char *filename) {
  1344.     if (index_ != NULL && filename != NULL) {
  1345.         char * pos = strrchr(filename, '.');
  1346.         PT_Index__Old cache = &index_->slots.formatOld;
  1347.         long int ndxSize;
  1348.         cache->filenameDat[0] = '\0';
  1349.         cache->filenameNdx[0] = '\0';
  1350.         cache->path[0] = '\0';
  1351.  
  1352.         {
  1353.             PT_Index__Old index = cache;
  1354.             const char * abpath;
  1355.             int slashes;
  1356.             /* -------------------- COPY OF THE __New() CODE -------------------- */
  1357.             /* Compute base path for this index - the filename MUST be absolute! */
  1358.             for(slashes = 2, abpath = filename + (int)strlen(filename) - 1 
  1359.                 ; abpath > filename && ( ( *abpath != '/'&& *abpath != '\\' ) || --slashes > 0)
  1360.                 ; abpath--);
  1361.             index->path[0] = '\0';
  1362.             if (slashes == 0 && *abpath != 0) {
  1363.                 int i;
  1364.                 strncat(index->path, filename, (int) ( abpath - filename ) + 1 );
  1365.                 for(i = 0 ; index->path[i] != 0 ; i++) {
  1366.                     if (index->path[i] == '\\') {
  1367.                         index->path[i] = '/';
  1368.                     }
  1369.                 }
  1370.             }
  1371.             /* -------------------- END OF COPY OF THE __New() CODE -------------------- */
  1372.         }
  1373.  
  1374.         /* Index/data filenames */
  1375.         if (pos != NULL) {
  1376.             int nLen = (int) (pos - filename);
  1377.             strncat(cache->filenameDat, filename, nLen);
  1378.             strncat(cache->filenameNdx, filename, nLen);
  1379.             strcat(cache->filenameDat, ".dat");
  1380.             strcat(cache->filenameNdx, ".ndx");
  1381.         }
  1382.         ndxSize = filesize(cache->filenameNdx);
  1383.         cache->timestamp = file_timestamp(cache->filenameDat);
  1384.         cache->dat = fopen(cache->filenameDat, "rb");
  1385.         cache->ndx = fopen(cache->filenameNdx, "rb");
  1386.         if (cache->dat != NULL && cache->ndx != NULL && ndxSize > 0) {
  1387.             char * use = malloc(ndxSize + 1);
  1388.             if (fread(use, 1, ndxSize, cache->ndx) == ndxSize) {
  1389.                 char firstline[256];
  1390.                 char* a=use;
  1391.                 use[ndxSize] = '\0';
  1392.                 a += cache_brstr(a, firstline);
  1393.                 if (strncmp(firstline,"CACHE-",6)==0) {       // Nouvelle version du cache
  1394.                     if (strncmp(firstline,"CACHE-1.",8)==0) {      // Version 1.1x
  1395.                         cache->version=(int)(firstline[8]-'0');           // cache 1.x
  1396.                         if (cache->version <= 5) {
  1397.                             a+=cache_brstr(a,firstline);
  1398.                             strcpy(cache->lastmodified,firstline);
  1399.                         } else {
  1400.                             // fprintf(opt->errlog,"Cache: version 1.%d not supported, ignoring current cache"LF,cache->version);
  1401.                             fclose(cache->dat);
  1402.                             cache->dat=NULL;
  1403.                             free(use);
  1404.                             use=NULL;
  1405.                         }
  1406.                     } else {        // non supportΘ
  1407.                         // fspc(opt->errlog,"error"); fprintf(opt->errlog,"Cache: %s not supported, ignoring current cache"LF,firstline);
  1408.                         fclose(cache->dat);
  1409.                         cache->dat=NULL;
  1410.                         free(use);
  1411.                         use=NULL;
  1412.                     }
  1413.                     /* */
  1414.                 } else {              // Vieille version du cache
  1415.                     /* */
  1416.                     // HTS_LOG(opt,LOG_WARNING); fprintf(opt->log,"Cache: importing old cache format"LF);
  1417.                     cache->version=0;        // cache 1.0
  1418.                     strcpy(cache->lastmodified,firstline); 
  1419.                 }
  1420.  
  1421.                 /* Create hash table for the cache (MUCH FASTER!) */
  1422.                 if (use) {
  1423.                     char line[HTS_URLMAXSIZE*2];
  1424.                     char linepos[256];
  1425.                     int  pos;
  1426.                     int firstSeen = 0;
  1427.                     while ( (a!=NULL) && (a < (use + ndxSize) ) ) {
  1428.                         a=strchr(a+1,'\n');     /* start of line */
  1429.                         if (a) {
  1430.                             a++;
  1431.                             /* read "host/file" */
  1432.                             a+=binput(a,line,HTS_URLMAXSIZE);
  1433.                             a+=binput(a,line+strlen(line),HTS_URLMAXSIZE);
  1434.                             /* read position */
  1435.                             a+=binput(a,linepos,200);
  1436.                             sscanf(linepos,"%d",&pos);
  1437.  
  1438.                             /* Add entry */
  1439.                             inthash_add(cache->hash,line,pos);
  1440.  
  1441.                             /* First link as starting URL */
  1442.                             if (!firstSeen) {
  1443.                                 if (strstr(line, "/robots.txt") == NULL) {
  1444.                                     PT_Index__Old index = cache;
  1445.                                     firstSeen = 1;
  1446.                                     if (!link_has_authority(line))
  1447.                                         strcat(index->startUrl, "http://");
  1448.                                     strcat(index->startUrl, line);
  1449.                                 }
  1450.                             }
  1451.  
  1452.                         }
  1453.                     }
  1454.                     /* Not needed anymore! */
  1455.                     free(use);
  1456.                     use=NULL;
  1457.                     return 1;
  1458.                 }
  1459.             }
  1460.         }
  1461.     }
  1462.     return 0;
  1463. }
  1464.  
  1465. static String DecodeUrl(const char * url) {
  1466.     int i;
  1467.     String s = STRING_EMPTY;
  1468.     StringClear(s);
  1469.     for(i = 0 ; url[i] != '\0' ; i++) {
  1470.         if (url[i] == '+') {
  1471.             StringAddchar(s, ' ');
  1472.         } else if (url[i] == '%') {
  1473.             if (url[i + 1] == '%') {
  1474.                 StringAddchar(s, '%');
  1475.                 i++;
  1476.             } else if (url[i + 1] != 0 && url[i + 2] != 0) {
  1477.                 char tmp[3];
  1478.                 int codepoint = 0;
  1479.                 tmp[0] = url[i + 1];
  1480.                 tmp[1] = url[i + 2];
  1481.                 tmp[2] = 0;
  1482.                 if (sscanf(tmp, "%x", &codepoint) == 1) {
  1483.                     StringAddchar(s, (char)codepoint);
  1484.                 }
  1485.                 i += 2;
  1486.             }
  1487.         } else {
  1488.             StringAddchar(s, url[i]);
  1489.         }
  1490.     }
  1491.     return s;
  1492. }
  1493.  
  1494. static PT_Element PT_ReadCache__Old(PT_Index index, const char* url, int flags) {
  1495.     PT_Element retCode;
  1496.     MutexLock(&index->slots.formatOld.fileLock);
  1497.     {
  1498.         retCode = PT_ReadCache__Old_u(index, url, flags);
  1499.     }
  1500.     MutexUnlock(&index->slots.formatOld.fileLock);
  1501.     return retCode;
  1502. }
  1503.  
  1504. static PT_Element PT_ReadCache__Old_u(PT_Index index_, const char* url, int flags) {
  1505.     PT_Index__Old cache = (PT_Index__Old) &index_->slots.formatOld;
  1506.   intptr_t hash_pos;
  1507.   int hash_pos_return;
  1508.   char location_default[HTS_URLMAXSIZE*2];
  1509.   char previous_save[HTS_URLMAXSIZE*2];
  1510.   char previous_save_[HTS_URLMAXSIZE*2];
  1511.   PT_Element r;
  1512.   int ok=0;
  1513.  
  1514.     if (cache == NULL || cache->hash == NULL || url == NULL || *url == 0)
  1515.         return NULL;
  1516.     if ((r = PT_ElementNew()) == NULL)
  1517.         return NULL;
  1518.     location_default[0] = '\0';
  1519.     previous_save[0] = previous_save_[0] = '\0';
  1520.   memset(r, 0, sizeof(_PT_Element));
  1521.   r->location = location_default;
  1522.     strcpy(r->location, ""); 
  1523.     if (strncmp(url, "http://", 7) == 0)
  1524.         url += 7;
  1525.   hash_pos_return=inthash_read(cache->hash, url, &hash_pos);
  1526.  
  1527.   if (hash_pos_return) {
  1528.     int pos = (int) hash_pos;     /* simply */
  1529.  
  1530.     if (fseek(cache->dat, (pos>0) ? pos : (-pos), SEEK_SET) == 0) {
  1531.             /* Importer cache1.0 */
  1532.             if (cache->version==0) {
  1533.                 OLD_htsblk old_r;
  1534.                 if (fread((char*) &old_r,1,sizeof(old_r),cache->dat) == sizeof(old_r)) { // lire tout (y compris statuscode etc)
  1535.                     int i;
  1536.                     String urlDecoded;
  1537.                     r->statuscode = old_r.statuscode;
  1538.                     r->size = old_r.size;        // taille fichier
  1539.                     strcpy(r->msg, old_r.msg);
  1540.                     strcpy(r->contenttype, old_r.contenttype);
  1541.  
  1542.                     /* Guess the destination filename.. this sucks, because this method is not reliable.
  1543.                         Yes, the old 1.0 cache format was *that* bogus. /rx */
  1544. #define FORBIDDEN_CHAR(c) (c == '~' \
  1545.     || c == '\\' \
  1546.     || c == ':' \
  1547.     || c == '*' \
  1548.     || c == '?' \
  1549.     || c == '\"' \
  1550.     || c == '<' \
  1551.     || c == '>' \
  1552.     || c == '|' \
  1553.     || c == '@' \
  1554.     || ((unsigned char) c ) <= 31 \
  1555.     || ((unsigned char) c ) == 127 \
  1556.     )
  1557.                     urlDecoded = DecodeUrl(jump_protocol_and_auth(url));
  1558.                     strcpy(previous_save_, StringBuff(urlDecoded));
  1559.                     StringFree(urlDecoded);
  1560.                     for(i = 0 ; previous_save_[i] != '\0' && previous_save_[i] != '?' ; i++) {
  1561.                         if (FORBIDDEN_CHAR(previous_save_[i])) {
  1562.                             previous_save_[i] = '_';
  1563.                         }
  1564.                     }
  1565.                     previous_save_[i] = '\0';
  1566. #undef FORBIDDEN_CHAR
  1567.                 ok = 1;     /* import  ok */
  1568.             }
  1569.       /* */
  1570.       /* Cache 1.1 */
  1571.       } else {
  1572.         char check[256];
  1573.         unsigned long size_read;
  1574.         unsigned long int size_;
  1575.         check[0]='\0';
  1576.         //
  1577.         cache_rint(cache->dat,&r->statuscode);
  1578.         cache_rLLint(cache->dat,&size_);
  1579.         r->size = (size_t) size_;
  1580.         cache_rstr(cache->dat,r->msg);
  1581.         cache_rstr(cache->dat,r->contenttype);
  1582.         if (cache->version >= 3)
  1583.           cache_rstr(cache->dat,r->charset);
  1584.         cache_rstr(cache->dat,r->lastmodified);
  1585.         cache_rstr(cache->dat,r->etag);
  1586.         cache_rstr(cache->dat,r->location);
  1587.         if (cache->version >= 2)
  1588.           cache_rstr(cache->dat,r->cdispo);
  1589.         if (cache->version >= 4) {
  1590.           cache_rstr(cache->dat, previous_save_);  // adr
  1591.           cache_rstr(cache->dat, previous_save_);  // fil
  1592.           previous_save[0] = '\0';
  1593.           cache_rstr(cache->dat, previous_save_);  // save
  1594.         }
  1595.         if (cache->version >= 5) {
  1596.           r->headers = cache_rstr_addr(cache->dat);
  1597.         }
  1598.         //
  1599.         cache_rstr(cache->dat,check);
  1600.         if (strcmp(check,"HTS")==0) {           /* intΘgritΘ OK */
  1601.           ok=1;
  1602.         }
  1603.         cache_rLLint(cache->dat, &size_read);       /* lire size pour Ωtre s√r de la taille dΘclarΘe (rΘΘcrire) */
  1604.         if (size_read > 0) {                         /* si inscrite ici */
  1605.           r->size = size_read;
  1606.         } else {                              /* pas de donnΘes directement dans le cache, fichier prΘsent? */
  1607.                     r->size = 0;
  1608.         }
  1609.       }
  1610.  
  1611.             /* Check destination filename */
  1612.  
  1613.             {
  1614.                 PT_Index__Old index = cache;
  1615.                 /* -------------------- COPY OF THE __New() CODE -------------------- */
  1616.                 if (previous_save_[0] != '\0') {
  1617.                     int pathLen = (int) strlen(index->path);
  1618.                     if (pathLen > 0 && strncmp(previous_save_, index->path, pathLen) == 0) {            // old (<3.40) buggy format
  1619.                         strcpy(previous_save, previous_save_);
  1620.                     }
  1621.                     // relative ? (hack)
  1622.                     else if (index->safeCache
  1623.                         || (previous_save_[0] != '/'                                                                    // /home/foo/bar.gif
  1624.                         && ( !isalpha(previous_save_[0]) || previous_save_[1] != ':' ) )    // c:/home/foo/bar.gif
  1625.                         )
  1626.                     {
  1627.                         index->safeCache = 1;
  1628.                         sprintf(previous_save, "%s%s", index->path, previous_save_);
  1629.                     }
  1630.                     // bogus format (includes buggy absolute path)
  1631.                     else {
  1632.                         /* guess previous path */
  1633.                         if (index->fixedPath == 0) {
  1634.                             const char * start = jump_protocol_and_auth(url);
  1635.                             const char * end = start ? strchr(start, '/') : NULL;
  1636.                             int len = (int) (end - start);
  1637.                             if (start != NULL && end != NULL && len > 0 && len < 128) {
  1638.                                 char piece[128 + 2];
  1639.                                 const char * where;
  1640.                                 piece[0] = '\0';
  1641.                                 strncat(piece, start, len);
  1642.                                 if ((where = strstr(previous_save_, piece)) != NULL) {
  1643.                                     index->fixedPath = (int) (where - previous_save_);        // offset to relative path
  1644.                                 }
  1645.                             }
  1646.                         }
  1647.                         if (index->fixedPath > 0) {
  1648.                             int saveLen = (int) strlen(previous_save_);
  1649.                             if (index->fixedPath < saveLen) {
  1650.                                 sprintf(previous_save, "%s%s", index->path, previous_save_ + index->fixedPath);
  1651.                             } else {
  1652.                                 sprintf(r->msg, "Bogus fixePath prefix for %s (prefixLen=%d)", previous_save_, (int)index->fixedPath);
  1653.                                 r->statuscode = STATUSCODE_INVALID;
  1654.                             }
  1655.                         } else {
  1656.                             sprintf(previous_save, "%s%s", index->path, previous_save_);
  1657.                         }
  1658.                     }
  1659.                 }
  1660.                 /* -------------------- END OF COPY OF THE __New() CODE -------------------- */
  1661.             }
  1662.  
  1663.       /* Read data */
  1664.             if (ok) {
  1665.                 r->adr = NULL;
  1666.                 if ( (r->statuscode>=0) && (r->statuscode<=999)) {
  1667.                     r->adr = NULL;
  1668.                     if (pos<0) {
  1669.                         if (flags & FETCH_BODY) {
  1670.                             FILE* fp = fopen(previous_save, "rb");
  1671.                             if (fp != NULL) {
  1672.                                 r->adr = (char*) malloc(r->size + 1);
  1673.                                 if (r->adr != NULL) {
  1674.                                     if (r->size > 0 && fread(r->adr, 1, r->size, fp) != r->size) {
  1675.                                         r->statuscode=STATUSCODE_INVALID;
  1676.                                         strcpy(r->msg,"Read error in cache disk data");
  1677.                                     }
  1678.                                     r->adr[r->size] = '\0';
  1679.                                 } else {
  1680.                                     r->statuscode=STATUSCODE_INVALID;
  1681.                                     strcpy(r->msg,"Read error (memory exhausted) from cache");
  1682.                                 }
  1683.                                 fclose(fp);
  1684.                             } else {
  1685.                                 r->statuscode = STATUSCODE_INVALID;
  1686.                                 strcpy(r->msg, "Previous cache file not found (2)");
  1687.                             }
  1688.                         }
  1689.                     } else {
  1690.                         // lire fichier (d'un coup)
  1691.                         if (flags & FETCH_BODY) {
  1692.                             r->adr=(char*) malloc(r->size + 1);
  1693.                             if (r->adr!=NULL) {
  1694.                                 if (fread(r->adr, 1, r->size,cache->dat) != r->size) {  // erreur
  1695.                                     free(r->adr);
  1696.                                     r->adr=NULL;
  1697.                                     r->statuscode=STATUSCODE_INVALID;
  1698.                                     strcpy(r->msg,"Cache Read Error : Read Data");
  1699.                                 } else
  1700.                                     r->adr[r->size] = '\0';
  1701.                             } else {  // erreur
  1702.                                 r->statuscode=STATUSCODE_INVALID;
  1703.                                 strcpy(r->msg,"Cache Memory Error");
  1704.                             }
  1705.                         }
  1706.                     }
  1707.                 } else {
  1708.           r->statuscode=STATUSCODE_INVALID;
  1709.           strcpy(r->msg,"Cache Read Error : Bad Data");
  1710.         }
  1711.       } else {  // erreur
  1712.         r->statuscode=STATUSCODE_INVALID;
  1713.         strcpy(r->msg,"Cache Read Error : Read Header");
  1714.       }
  1715.     } else {
  1716.       r->statuscode=STATUSCODE_INVALID;
  1717.       strcpy(r->msg,"Cache Read Error : Seek Failed");
  1718.     }
  1719.   } else {
  1720.     r->statuscode=STATUSCODE_INVALID;
  1721.     strcpy(r->msg,"File Cache Entry Not Found");
  1722.   }
  1723.     if (r->location[0] != '\0') {
  1724.         r->location = strdup(r->location);
  1725.     } else {
  1726.         r->location = NULL;
  1727.     }
  1728.   return r;
  1729. }
  1730.  
  1731. static int PT_LookupCache__Old(PT_Index index, const char* url) {
  1732.     int retCode;
  1733.     MutexLock(&index->slots.formatOld.fileLock);
  1734.     {
  1735.         retCode = PT_LookupCache__Old_u(index, url);
  1736.     }
  1737.     MutexUnlock(&index->slots.formatOld.fileLock);
  1738.     return retCode;
  1739. }
  1740.  
  1741. static int PT_LookupCache__Old_u(PT_Index index_, const char* url) {
  1742.     if (index_ != NULL) {
  1743.         PT_Index__New cache = (PT_Index__New) &index_->slots.formatNew;
  1744.         if (cache == NULL || cache->hash == NULL || url == NULL || *url == 0)
  1745.             return 0;
  1746.         if (strncmp(url, "http://", 7) == 0)
  1747.             url += 7;
  1748.         if (inthash_read(cache->hash, url, NULL))
  1749.             return 1;
  1750.     }
  1751.     return 0;
  1752. }
  1753.  
  1754.  
  1755. /* ------------------------------------------------------------ */
  1756. /* Internet Archive Arc 1.0 (arc) format                        */
  1757. /* Xavier Roche (roche@httrack.com)                             */
  1758. /* Lars Clausen (lc@statsbiblioteket.dk)                        */
  1759. /* ------------------------------------------------------------ */
  1760.  
  1761. #define ARC_SP ' '
  1762.  
  1763. static const char* getArcField(const char *line, int pos) {
  1764.     int i;
  1765.     for(i = 0 ; line[i] != '\0' && pos > 0 ; i++) {
  1766.         if (line[i] == ARC_SP)
  1767.             pos--;
  1768.     }
  1769.     if (pos == 0)
  1770.         return &line[i];
  1771.     return NULL;
  1772. }
  1773.  
  1774. static char* copyArcField(const char *line, int npos, char *dest, int destMax) {
  1775.     const char *pos;
  1776.     if ((pos = getArcField(line, npos)) != NULL) {
  1777.         int i;
  1778.         for(i = 0 ; pos[i] != '\0' && pos[i] != ARC_SP && ( --destMax ) > 0; i++) {
  1779.             dest[i] = pos[i];
  1780.         }
  1781.         dest[i] = 0;
  1782.         return dest;
  1783.     }
  1784.     dest[0] = 0;
  1785.     return NULL;
  1786. }
  1787.  
  1788. static int getArcLength(const char *line) {
  1789.     const char *pos;
  1790.     if ((pos = getArcField(line, 9)) != NULL 
  1791.         || (pos = getArcField(line, 4)) != NULL 
  1792.         || (pos = getArcField(line, 2)) != NULL
  1793.         ) {
  1794.         int length;
  1795.         if (sscanf(pos, "%d", &length) == 1) {
  1796.             return length;
  1797.         }
  1798.     }
  1799.     return -1;
  1800. }
  1801.  
  1802. static int skipArcNl(FILE* file) {
  1803.     if (fgetc(file) == 0x0a) {
  1804.         return 0;
  1805.     }
  1806.     return -1;
  1807. }
  1808.  
  1809. static int skipArcData(FILE* file, const char *line) {
  1810.     int jump = getArcLength(line);
  1811.     if (jump != -1) {
  1812.         if (fseek(file, jump, SEEK_CUR) == 0 /* && skipArcNl(file) == 0 */) {
  1813.             return 0;
  1814.         }
  1815.     }
  1816.     return -1;
  1817. }
  1818.  
  1819. static int getDigit(const char digit) {
  1820.     return (int) ( digit - '0' );
  1821. }
  1822.  
  1823. static int getDigit2(const char * const pos) {
  1824.     return getDigit(pos[0])*10 + getDigit(pos[1]);
  1825. }
  1826.  
  1827. static int getDigit4(const char * const pos) {
  1828.     return getDigit(pos[0])*1000 + getDigit(pos[1])*100 + getDigit(pos[2])*10 + getDigit(pos[3]);
  1829. }
  1830.  
  1831. static time_t getGMT(struct tm *tm) {        /* hey, time_t is local! */
  1832.     time_t t = mktime(tm);
  1833.     if (t != (time_t) -1 && t != (time_t) 0) {
  1834.     /* BSD does not have static "timezone" declared */
  1835. #if (defined(BSD) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__FreeBSD_kernel__))
  1836.     time_t now = time(NULL); 
  1837.     time_t timezone = - localtime(&now)->tm_gmtoff;
  1838. #endif
  1839.         return (time_t) (t - timezone);
  1840.     }
  1841.     return (time_t) -1;
  1842. }
  1843.  
  1844. static time_t getArcTimestamp(const char * const line) {
  1845.     const char *pos;
  1846.     if ((pos = getArcField(line, 2)) != NULL) {
  1847.         int i;
  1848.         /* date == YYYYMMDDhhmmss (Greenwich Mean Time) */
  1849.         /* example: 20050405154029  */
  1850.         for(i = 0 ; pos[i] >= '0' && pos[i] <= '9' ; i++);
  1851.         if (i == 14) {
  1852.             struct tm tm;
  1853.             memset(&tm, 0, sizeof(tm));
  1854.             tm.tm_year = getDigit4(pos + 0) - 1900;    /* current year minus 1900 */
  1855.             tm.tm_mon =  getDigit2(pos + 4) - 1;        /* 0 û 11 */
  1856.             tm.tm_mday = getDigit2(pos + 6);                /* 1 û 31 */
  1857.             tm.tm_hour = getDigit2(pos + 8);                /* 0 û 23 */
  1858.             tm.tm_min =  getDigit2(pos + 10);                /* 0 û 59 */
  1859.             tm.tm_sec =  getDigit2(pos + 12);                /* 0 û 59 */
  1860.             tm.tm_isdst = 0;
  1861.             return getGMT(&tm);
  1862.         }
  1863.     }
  1864.     return (time_t) -1;
  1865. }
  1866.  
  1867. static int readArcURLRecord(PT_Index__Arc index) {
  1868.     index->line[0] = '\0';
  1869.     if (linput(index->file, index->line, sizeof(index->line) - 1)) {
  1870.         return 0;
  1871.     }
  1872.     return -1;
  1873. }
  1874.  
  1875. #define str_begins(str, sstr) ( strncmp(str, sstr, sizeof(sstr) - 1) == 0 )
  1876. static int PT_CompatibleScheme(const char *url) {
  1877.     return (str_begins(url, "http:") 
  1878.         || str_begins(url, "https:") 
  1879.         || str_begins(url, "ftp:") 
  1880.         || str_begins(url, "file:"));
  1881. }
  1882.  
  1883. int PT_LoadCache__Arc(PT_Index index_, const char *filename) {
  1884.     if (index_ != NULL && filename != NULL) {
  1885.         PT_Index__Arc index = &index_->slots.formatArc;
  1886.         index->timestamp = file_timestamp(filename);
  1887.         MutexInit(&index->fileLock);
  1888.         index->file = fopen(filename, "rb");
  1889.  
  1890.         // Opened ?
  1891.         if (index->file != NULL) {
  1892.             inthash hashtable = index->hash;
  1893.             if (readArcURLRecord(index) == 0) {
  1894.                 int entries = 0;
  1895.                 /* Read first line */
  1896.                 if (strncmp(index->line, "filedesc://", sizeof("filedesc://") - 1) != 0) {
  1897.                     fprintf(stderr, "Unexpected bad signature #%s"LF, index->line);
  1898.                     fclose(index->file);
  1899.                     index->file = NULL;
  1900.                     return 0;
  1901.                 }
  1902.                 /* Timestamp */
  1903.                 index->timestamp = getArcTimestamp(index->line);
  1904.                 /* Skip first entry */
  1905.                 if (skipArcData(index->file, index->line) != 0 || skipArcNl(index->file) != 0) {
  1906.                     fprintf(stderr, "Unexpected bad data offset size first entry"LF);
  1907.                     fclose(index->file);
  1908.                     index->file = NULL;
  1909.                     return 0;
  1910.                 }
  1911.                 /* Read all meta-entries (not data) */
  1912.                 while(!feof(index->file)) {
  1913.                     unsigned long int fpos = ftell(index->file);
  1914.                     if (skipArcNl(index->file) == 0 && readArcURLRecord(index) == 0) {
  1915.                         int length = getArcLength(index->line);
  1916.                         if (length >= 0) {
  1917.                             const char * filenameIndex = copyArcField(index->line, 0, 
  1918.                                 index->filenameIndexBuff, sizeof(index->filenameIndexBuff) - 1);  /* can not be NULL */
  1919.                             if (strncmp(filenameIndex, "http://", 7) == 0) {
  1920.                                 filenameIndex += 7;
  1921.                             }
  1922.                             if (*filenameIndex != 0) {
  1923.                                 if (skipArcData(index->file, index->line) != 0) {
  1924.                                     fprintf(stderr, "Corrupted cache data entry #%d (truncated file?), aborting read"LF, (int)entries);
  1925.                                 }
  1926.                                 /*fprintf(stdout, "adding %s [%d]\n", filenameIndex, (int)fpos);*/
  1927.                                 if (PT_CompatibleScheme(index->filenameIndexBuff)) {
  1928.                                     inthash_add(hashtable, filenameIndex, fpos);        /* position of meta-data */
  1929.                                     entries++;
  1930.                                 }
  1931.                             } else {
  1932.                                 fprintf(stderr, "Corrupted cache meta entry #%d"LF, (int)entries);
  1933.                             }
  1934.                         } else {
  1935.                             fprintf(stderr, "Corrupted cache meta entry #%d, aborting read"LF, (int)entries);
  1936.                             break ;
  1937.                         }
  1938.                     } else {
  1939.                         break ;
  1940.                     }
  1941.                 }
  1942.  
  1943.                 /* OK */
  1944.                 return 1;
  1945.             } else {
  1946.                 fprintf(stderr, "Bad file (empty ?)"LF);
  1947.             }
  1948.         } else {
  1949.             fprintf(stderr, "Unable to open file"LF);
  1950.             index = NULL;
  1951.         }
  1952.     } else {
  1953.         fprintf(stderr, "Bad arguments"LF);
  1954.     }
  1955.     return 0;
  1956. }
  1957.  
  1958. #define HTTP_READFIELD_STRING(line, value, refline, refvalue) do { \
  1959.   if (line[0] != '\0' && strfield2(line, refline)) { \
  1960.     strcpy(refvalue, value); \
  1961.     line[0] = '\0'; \
  1962.     } \
  1963. } while(0)
  1964. #define HTTP_READFIELD_INT(line, value, refline, refvalue) do { \
  1965.   if (line[0] != '\0' && strfield2(line, refline)) { \
  1966.     int intval = 0; \
  1967.     sscanf(value, "%d", &intval); \
  1968.     (refvalue) = intval; \
  1969.     line[0] = '\0'; \
  1970.     } \
  1971. } while(0)
  1972.  
  1973. static PT_Element PT_ReadCache__Arc(PT_Index index, const char* url, int flags) {
  1974.     PT_Element retCode;
  1975.     MutexLock(&index->slots.formatArc.fileLock);
  1976.     {
  1977.         retCode = PT_ReadCache__Arc_u(index, url, flags);
  1978.     }
  1979.     MutexUnlock(&index->slots.formatArc.fileLock);
  1980.     return retCode;
  1981. }
  1982.  
  1983. static PT_Element PT_ReadCache__Arc_u(PT_Index index_, const char* url, int flags)
  1984. {
  1985.     PT_Index__Arc index = (PT_Index__Arc) &index_->slots.formatArc;
  1986.     char location_default[HTS_URLMAXSIZE*2];
  1987.   intptr_t hash_pos;
  1988.   int hash_pos_return;
  1989.     PT_Element r = NULL;
  1990.     if (index == NULL || index->hash == NULL || url == NULL || *url == 0)
  1991.         return NULL;
  1992.     if ((r = PT_ElementNew()) == NULL)
  1993.         return NULL;
  1994.     location_default[0] = '\0';
  1995.   memset(r, 0, sizeof(_PT_Element));
  1996.   r->location = location_default;
  1997.     strcpy(r->location, ""); 
  1998.     if (strncmp(url, "http://", 7) == 0)
  1999.         url += 7;
  2000.   hash_pos_return = inthash_read(index->hash, url, &hash_pos);
  2001.  
  2002.     if (hash_pos_return) {
  2003.         if (fseek(index->file, (long)hash_pos, SEEK_SET) == 0) {
  2004.             if (skipArcNl(index->file) == 0 && readArcURLRecord(index) == 0) {
  2005.                 long int fposMeta = ftell(index->file);
  2006.                 int dataLength = getArcLength(index->line);
  2007.                 const char *pos;
  2008.  
  2009.                 /* Read HTTP headers */
  2010.                 /* HTTP/1.1 404 Not Found */
  2011.                 if (linput(index->file, index->line, sizeof(index->line) - 1)) {
  2012.                     if ((pos = getArcField(index->line, 1)) != NULL) {
  2013.                         if (sscanf(pos, "%d", &r->statuscode) != 1) {
  2014.                             r->statuscode = STATUSCODE_INVALID;
  2015.                         }
  2016.                     }
  2017.                     if ((pos = getArcField(index->line, 2)) != NULL) {
  2018.                         r->msg[0] = '\0';
  2019.                         strncat(r->msg, pos, sizeof(pos) - 1);
  2020.                     }
  2021.                     while (linput(index->file, index->line, sizeof(index->line) - 1) && index->line[0] != '\0') {
  2022.                         char* const line = index->line;
  2023.                         char* value = strchr(line, ':');
  2024.                         if (value != NULL) {
  2025.                             *value = '\0';
  2026.                             for( value++ ; *value == ' ' || *value == '\t' ; value++);
  2027.                             HTTP_READFIELD_INT(line, value, "Content-Length", r->size);           // size
  2028.                             HTTP_READFIELD_STRING(line, value, "Content-Type", r->contenttype);      // contenttype
  2029.                             HTTP_READFIELD_STRING(line, value, "Last-Modified", r->lastmodified);     // last-modified
  2030.                             HTTP_READFIELD_STRING(line, value, "Etag", r->etag);             // Etag
  2031.                             HTTP_READFIELD_STRING(line, value, "Location", r->location);         // 'location' pour moved
  2032.                             HTTP_READFIELD_STRING(line, value, "Content-Disposition", r->cdispo);           // Content-disposition
  2033.                             if (line[0] != '\0') {
  2034.                                 int len = r->headers ? ((int) strlen(r->headers)) : 0;
  2035.                                 int nlen = (int) ( strlen(line) + 2 + strlen(value) + sizeof("\r\n") + 1 );
  2036.                                 r->headers = realloc(r->headers, len + nlen);
  2037.                                 r->headers[len] = '\0';
  2038.                                 strcat(r->headers, line);
  2039.                                 strcat(r->headers, ": ");
  2040.                                 strcat(r->headers, value);
  2041.                                 strcat(r->headers, "\r\n");
  2042.                             }
  2043.                         }
  2044.                     }
  2045.  
  2046.                     /* FIXME charset */
  2047.                     if (r->contenttype[0] != '\0') {
  2048.                         char *pos = strchr(r->contenttype, ';');
  2049.                         if (pos != NULL) {
  2050.                             /*char *chs = strchr(pos, "charset=");*/
  2051.                             /*HTTP_READFIELD_STRING(line, value, "X-Charset", r->charset);*/
  2052.                             *pos = 0;
  2053.                             if ((pos = strchr(r->contenttype, ' ')) != NULL) {
  2054.                                 *pos = 0;
  2055.                             }
  2056.                         }
  2057.                     }
  2058.  
  2059.                     /* Read data */
  2060.                     if (r->statuscode != STATUSCODE_INVALID) {            /* Can continue */
  2061.                         if (flags & FETCH_BODY) {
  2062.                             long int fposCurrent = ftell(index->file);
  2063.                             long int metaSize = fposCurrent - fposMeta;
  2064.                             long int fetchSize = (long int) r->size;
  2065.                             if (fetchSize <= 0) {
  2066.                                 fetchSize = dataLength - metaSize;
  2067.                             } else if (fetchSize > dataLength - metaSize) {
  2068.                                 r->statuscode=STATUSCODE_INVALID;
  2069.                                 strcpy(r->msg, "Cache Read Error : Truncated Data");
  2070.                             }
  2071.                             r->size = 0;
  2072.                             if (r->statuscode != STATUSCODE_INVALID) {
  2073.                                 r->adr = (char*) malloc(fetchSize);
  2074.                                 if (r->adr != NULL) {
  2075.                                     if (fetchSize > 0 && ( r->size = (int) fread(r->adr, 1,  fetchSize, index->file) ) != fetchSize) {
  2076.                     int last_errno = errno;
  2077.                                         r->statuscode=STATUSCODE_INVALID;
  2078.                                         sprintf(r->msg,"Read error in cache disk data: %s", strerror(last_errno));
  2079.                                     }
  2080.                                 } else {
  2081.                                     r->statuscode=STATUSCODE_INVALID;
  2082.                                     strcpy(r->msg,"Read error (memory exhausted) from cache");
  2083.                                 }
  2084.                             }
  2085.                         }
  2086.                     }
  2087.  
  2088.                 } else {
  2089.                     r->statuscode=STATUSCODE_INVALID;
  2090.                     strcpy(r->msg, "Cache Read Error : Read Header Error");
  2091.                 }
  2092.  
  2093.             } else {
  2094.                 r->statuscode=STATUSCODE_INVALID;
  2095.                 strcpy(r->msg, "Cache Read Error : Read Header Error");
  2096.             }
  2097.         } else {
  2098.             r->statuscode=STATUSCODE_INVALID;
  2099.             strcpy(r->msg, "Cache Read Error : Seek Error");
  2100.         }
  2101.  
  2102.     } else {
  2103.         r->statuscode=STATUSCODE_INVALID;
  2104.     strcpy(r->msg,"File Cache Entry Not Found");
  2105.   }
  2106.     if (r->location[0] != '\0') {
  2107.         r->location = strdup(r->location);
  2108.     } else {
  2109.         r->location = NULL;
  2110.     }
  2111.   return r;
  2112. }
  2113.  
  2114. static int PT_LookupCache__Arc(PT_Index index, const char* url) {
  2115.     int retCode;
  2116.     MutexLock(&index->slots.formatArc.fileLock);
  2117.     {
  2118.         retCode = PT_LookupCache__Arc_u(index, url);
  2119.     }
  2120.     MutexUnlock(&index->slots.formatArc.fileLock);
  2121.     return retCode;
  2122. }
  2123.  
  2124. static int PT_LookupCache__Arc_u(PT_Index index_, const char* url) {
  2125.     if (index_ != NULL) {
  2126.         PT_Index__New cache = (PT_Index__New) &index_->slots.formatNew;
  2127.         if (cache == NULL || cache->hash == NULL || url == NULL || *url == 0)
  2128.             return 0;
  2129.         if (strncmp(url, "http://", 7) == 0)
  2130.             url += 7;
  2131.         if (inthash_read(cache->hash, url, NULL))
  2132.             return 1;
  2133.     }
  2134.     return 0;
  2135. }
  2136.  
  2137. typedef struct PT_SaveCache__Arc_t {
  2138.     PT_Indexes indexes;
  2139.     FILE *fp;
  2140.     time_t t;
  2141.     char filename[64];
  2142.     struct tm buff;
  2143.     char headers[8192];
  2144.   char md5[32 + 2];
  2145. } PT_SaveCache__Arc_t;
  2146.  
  2147. static int PT_SaveCache__Arc_Fun(void *arg, const char *url, PT_Element element) {
  2148.     PT_SaveCache__Arc_t *st = (PT_SaveCache__Arc_t*) arg;
  2149.     FILE * const fp = st->fp;
  2150.     struct tm* tm = convert_time_rfc822(&st->buff, element->lastmodified);
  2151.     int size_headers;
  2152.  
  2153.     sprintf(st->headers, 
  2154.         "HTTP/1.0 %d %s" "\r\n"
  2155.         "X-Server: ProxyTrack " PROXYTRACK_VERSION "\r\n"
  2156.         "Content-type: %s%s%s%s" "\r\n"
  2157.         "Last-modified: %s" "\r\n"
  2158.         "Content-length: %d" "\r\n"
  2159.         ,
  2160.         element->statuscode, element->msg,
  2161.         /**/
  2162.         element->contenttype, 
  2163.         (element->charset[0] ? "; charset=\"" : ""), 
  2164.         (element->charset[0] ? element->charset : ""), 
  2165.         (element->charset[0] ? "\"" : ""),
  2166.         /**/
  2167.         element->lastmodified,
  2168.         (int) element->size
  2169.         );
  2170.     if (element->location != NULL && element->location[0] != '\0') {
  2171.         sprintf(st->headers + strlen(st->headers), "Location: %s" "\r\n", element->location);
  2172.     }
  2173.     if (element->headers != NULL) {
  2174.         if ( strlen(element->headers) < sizeof(st->headers) - strlen(element->headers) - 1 ) {
  2175.             strcat(st->headers, element->headers);
  2176.         }
  2177.     }
  2178.     strcat(st->headers, "\r\n");
  2179.     size_headers = (int) strlen(st->headers);
  2180.  
  2181.     /* doc == <nl><URL-record><nl><network_doc> */
  2182.  
  2183.   /* Format: URL IP date mime result checksum location offset filename length */
  2184.     if (element->adr != NULL) {
  2185.         domd5mem(element->adr, element->size, st->md5, 1);
  2186.     } else {
  2187.         strcpy(st->md5, "-");
  2188.     }
  2189.   fprintf(fp, 
  2190.         /* nl */
  2191.         "\n"
  2192.       /* URL-record */
  2193.         "%s%s %s %04d%02d%02d%02d%02d%02d %s %d %s %s %ld %s %ld"
  2194.         /* nl */
  2195.         "\n",
  2196.         /* args */
  2197.       ( link_has_authority(url) ? "" : "http://" ), url,
  2198.         "0.0.0.0",
  2199.         tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec,
  2200.       element->contenttype,
  2201.       element->statuscode,
  2202.         st->md5, ( element->location ? element->location : "-" ),
  2203.       (long int)ftell(fp), st->filename,
  2204.       (long int)( size_headers + element->size ));
  2205.     /* network_doc */
  2206.     if (fwrite(st->headers, 1, size_headers, fp) != size_headers
  2207.             || ( element->size > 0 && fwrite(element->adr, 1, element->size, fp) != element->size )
  2208.         ) {
  2209.         return 1;            /* Error */
  2210.     }
  2211.  
  2212.     return 0;
  2213. }
  2214.  
  2215. static int PT_SaveCache__Arc(PT_Indexes indexes, const char *filename) {
  2216.     FILE *fp = fopen(filename, "wb");
  2217.     if (fp != NULL) {
  2218.         PT_SaveCache__Arc_t st;
  2219.         int ret;
  2220.         time_t t = PT_GetTimeIndex(indexes);
  2221.         struct tm tm = PT_GetTime(t);
  2222.  
  2223.         /* version-2-block ==
  2224.         filedesc://<path><sp><ip_address><sp><date><sp>text/plain<sp>200<sp>-<sp>-<sp>0<sp><filename><sp><length><nl>
  2225.         2<sp><reserved><sp><origin-code><nl>
  2226.         URL<sp>IP-address<sp>Archive-date<sp>Content-type<sp>Result-code<sp>Checksum<sp>Location<sp> Offset<sp>Filename<sp>Archive-length<nl>
  2227.         <nl> */
  2228.         const char* prefix = 
  2229.             "2 0 HTTrack Website Copier" "\n"
  2230.             "URL IP-address Archive-Date Content-Type Result-code Checksum Location Offset Filename Archive-length" "\n" "\n";
  2231.         sprintf(st.filename, "httrack_%d.arc", (int) t);
  2232.         fprintf(fp, "filedesc://%s 0.0.0.0 %04d%02d%02d%02d%02d%02d text/plain 200 - - 0 %s %d" "\n"
  2233.             "%s",
  2234.             st.filename, 
  2235.             tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec,
  2236.             st.filename, (int)strlen(prefix), prefix);
  2237.         st.fp = fp;
  2238.         st.indexes = indexes;
  2239.         st.t = t;
  2240.         ret = PT_EnumCache(indexes, PT_SaveCache__Arc_Fun, (void *)&st);
  2241.         fclose(fp);
  2242.         if (ret != 0)
  2243.             (void) unlink(filename);
  2244.         return ret;
  2245.     }
  2246.     return -1;
  2247. }
  2248.